PC Plus SuperCD (UK) 1998 August/PC Plus SuperCD 50a Issue 142 (CD142a) (August 1998).iso/trial/demon/TURNPIKE.1/CLASSES.ZIP/sun/AWT/IMAGE/InputStreamImageSource.class

Java Class File | 1997-04-14 | 6.2 KB | 508 lines

package sun.awt.image;

import java.awt.image.ColorModel;
import java.awt.image.ImageConsumer;
import java.awt.image.ImageProducer;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;

abstract class InputStreamImageSource implements ImageProducer, ImageFetchable {
   PixelStore pixelstore;
   private ConsumerQueue consumers;
   private boolean awaitingFetch = false;
   private Thread latestFetcher;
   private ImageDecoder decoder;

   abstract boolean checkSecurity(Object var1, boolean var2);

   synchronized int countConsumers() {
      ConsumerQueue var1 = this.consumers;

      int var2;
      for(var2 = 0; var1 != null; var1 = var1.next) {
         ++var2;
      }

      return var2;
   }

   public void addConsumer(ImageConsumer var1) {
      this.addConsumer(var1, false);
   }

   synchronized void addConsumer(ImageConsumer var1, boolean var2) {
      this.checkSecurity((Object)null, false);

      ConsumerQueue var3;
      for(var3 = this.consumers; var3 != null && var3.consumer != var1; var3 = var3.next) {
      }

      if (var3 == null) {
         var3 = new ConsumerQueue(this, var1);
         var3.next = this.consumers;
         this.consumers = var3;
      } else {
         if (!var3.secure) {
            Object var4 = null;
            SecurityManager var5 = System.getSecurityManager();
            if (var5 != null) {
               var4 = var5.getSecurityContext();
            }

            if (var3.securityContext == null) {
               var3.securityContext = var4;
            } else if (var3.securityContext != var4) {
               this.errorConsumer(var3);
               throw new SecurityException("Applets are trading image data!");
            }
         }

         var3.interested = true;
      }

      if (var2 && var3.feeder == null && !this.awaitingFetch && this.latestFetcher == null) {
         this.startProduction();
      }

   }

   public synchronized boolean isConsumer(ImageConsumer var1) {
      for(ConsumerQueue var2 = this.consumers; var2 != null; var2 = var2.next) {
         if (var2.consumer == var1) {
            return true;
         }
      }

      return false;
   }

   synchronized void errorConsumer(ConsumerQueue var1) {
      var1.consumer.imageComplete(1);
      this.removeConsumer(var1.consumer);
   }

   public synchronized void removeConsumer(ImageConsumer var1) {
      ConsumerQueue var2 = this.consumers;

      for(ConsumerQueue var3 = null; var2 != null; var2 = var2.next) {
         if (var2.consumer == var1) {
            if (var3 == null) {
               this.consumers = var2.next;
            } else {
               var3.next = var2.next;
            }

            var2.interested = false;
            return;
         }

         var3 = var2;
      }

   }

   public void startProduction(ImageConsumer var1) {
      this.addConsumer(var1, true);
   }

   private synchronized void startProduction() {
      if (!this.awaitingFetch) {
         ImageFetcher.add(this);
         this.awaitingFetch = true;
      }

   }

   public void requestTopDownLeftRightResend(ImageConsumer var1) {
      synchronized(this){}

      PixelStore var2;
      try {
         var2 = this.pixelstore;
      } catch (Throwable var5) {
         throw var5;
      }

      if (var2 != null) {
         var2.replay(this, var1, false);
      }

   }

   protected abstract ImageDecoder getDecoder();

   protected ImageDecoder decoderForType(InputStream var1, String var2) {
      if (var2.equals("image/gif")) {
         return new GifImageDecoder(this, var1);
      } else if (var2.equals("image/jpeg")) {
         return new JPEGImageDecoder(this, var1);
      } else {
         return var2.equals("image/x-xbitmap") ? new XbmImageDecoder(this, var1) : null;
      }
   }

   protected ImageDecoder getDecoder(InputStream var1) {
      if (!((InputStream)var1).markSupported()) {
         var1 = new BufferedInputStream((InputStream)var1);
      }

      try {
         ((InputStream)var1).mark(1000);
         int var2 = ((InputStream)var1).read();
         int var3 = ((InputStream)var1).read();
         int var4 = ((InputStream)var1).read();
         int var5 = ((InputStream)var1).read();
         ((InputStream)var1).read();
         ((InputStream)var1).read();
         ((InputStream)var1).reset();
         if (var2 == 71 && var3 == 73 && var4 == 70 && var5 == 56) {
            return new GifImageDecoder(this, (InputStream)var1);
         }

         if (var2 == 255 && var3 == 216 && var4 == 255 && var5 == 224 || var2 == 255 && var3 == 216 && var4 == 255 && var5 == 238) {
            return new JPEGImageDecoder(this, (InputStream)var1);
         }

         if (var2 == 35 && var3 == 100 && var4 == 101 && var5 == 102) {
            return new XbmImageDecoder(this, (InputStream)var1);
         }
      } catch (IOException var6) {
      }

      return null;
   }

   public void doFetch() {
      Thread var1 = Thread.currentThread();
      ImageDecoder var2 = null;

      try {
         if (this.latchConsumers(var1) <= 0) {
            return;
         }

         if (!this.updateFromStore(var1)) {
            var2 = this.getDecoder();
            if (var2 != null) {
               this.setDecoder(var2, var1);

               try {
                  var2.produceImage();
               } catch (IOException var9) {
                  ((Throwable)var9).printStackTrace();
               } catch (ImageFormatException var10) {
                  ((Throwable)var10).printStackTrace();
               }

               return;
            }

            return;
         }
      } finally {
         this.imageComplete(1);
         this.unlatchConsumers(var2, var1);
      }

   }

   private boolean updateFromStore(Thread var1) {
      synchronized(this){}

      PixelStore var2;
      ConsumerQueue var3;
      try {
         var2 = this.pixelstore;
         if (var2 == null) {
            boolean var6 = false;
            return var6;
         }

         var3 = this.consumers;
      } catch (Throwable var18) {
         throw var18;
      }

      while(var3 != null) {
         synchronized(this){}

         try {
            if (var3.feeder == null) {
               if (!this.checkSecurity(var3.securityContext, true)) {
                  this.errorConsumer(var3);
               } else {
                  var3.feeder = var1;
               }
            }

            if (var3.feeder != var1) {
               var3 = var3.next;
               continue;
            }
         } catch (Throwable var17) {
            throw var17;
         }

         if (!var2.replay(this, var3.consumer)) {
            return false;
         }

         synchronized(this){}

         try {
            var3 = var3.next;
         } catch (Throwable var16) {
            throw var16;
         }
      }

      return true;
   }

   private synchronized void setDecoder(ImageDecoder var1, Thread var2) {
      for(ConsumerQueue var3 = this.consumers; var3 != null; var3 = var3.next) {
         if (var3.feeder == var2) {
            if (!this.checkSecurity(var3.securityContext, true)) {
               this.errorConsumer(var3);
            } else {
               var3.decoder = var1;
            }
         }
      }

      if (this.latestFetcher == var2) {
         this.decoder = var1;
      }

   }

   private synchronized int latchConsumers(Thread var1) {
      this.latestFetcher = var1;
      this.awaitingFetch = false;
      ConsumerQueue var2 = this.consumers;

      int var3;
      for(var3 = 0; var2 != null; var2 = var2.next) {
         if (var2.feeder == null) {
            if (!this.checkSecurity(var2.securityContext, true)) {
               this.errorConsumer(var2);
            } else {
               var2.feeder = var1;
               ++var3;
            }
         }
      }

      return var3;
   }

   private synchronized void unlatchConsumers(ImageDecoder var1, Thread var2) {
      if (this.latestFetcher == var2) {
         this.latestFetcher = null;
      }

      ConsumerQueue var3 = this.consumers;

      for(ConsumerQueue var4 = null; var3 != null; var3 = var3.next) {
         if (var3.feeder == var2) {
            if (var4 == null) {
               this.consumers = var3.next;
            } else {
               var4.next = var3.next;
            }
         } else {
            if (var3.feeder == null) {
               this.startProduction();
            }

            var4 = var3;
         }
      }

   }

   private ConsumerQueue nextConsumer(ConsumerQueue var1, Thread var2) {
      synchronized(this){}

      try {
         if (var1 == null) {
            var1 = this.consumers;
         } else {
            var1 = var1.next;
         }

         while(var1 != null) {
            if (var1.interested) {
               if (var1.feeder == var2) {
                  ConsumerQueue var5 = var1;
                  return var5;
               }

               if (var1.feeder == null && this.latestFetcher == var2) {
                  break;
               }

               var1 = var1.next;
            }
         }
      } catch (Throwable var17) {
         throw var17;
      }

      if (var1 != null) {
         if (this.decoder != null && this.decoder.catchupConsumer(this, var1.consumer)) {
            synchronized(this){}

            ConsumerQueue var19;
            try {
               if (!var1.interested) {
                  return this.nextConsumer(var1, var2);
               }

               if (!this.checkSecurity(var1.securityContext, true)) {
                  this.errorConsumer(var1);
                  return this.nextConsumer(var1, var2);
               }

               var1.feeder = var2;
               var1.decoder = this.decoder;
               var19 = var1;
            } catch (Throwable var16) {
               throw var16;
            }

            return var19;
         }

         synchronized(this){}

         try {
            this.latestFetcher = null;
            this.startProduction();
         } catch (Throwable var15) {
            throw var15;
         }
      }

      return var1;
   }

   synchronized void flush() {
      ConsumerQueue var1 = this.consumers;

      for(this.consumers = null; var1 != null; var1 = var1.next) {
         var1.interested = false;

         try {
            if (var1.feeder != null) {
               var1.feeder.interrupt();
            }
         } catch (NoSuchMethodError var2) {
            break;
         }

         if (var1.decoder != null) {
            var1.decoder.close();
         }
      }

      this.pixelstore = null;
   }

   synchronized void setPixelStore(PixelStore var1) {
      this.pixelstore = var1;
   }

   int setDimensions(int var1, int var2) {
      ConsumerQueue var3 = null;
      Thread var4 = Thread.currentThread();

      int var5;
      for(var5 = 0; (var3 = this.nextConsumer(var3, var4)) != null; ++var5) {
         var3.consumer.setDimensions(var1, var2);
      }

      return var5;
   }

   int setProperties(Hashtable var1) {
      ConsumerQueue var2 = null;
      Thread var3 = Thread.currentThread();

      int var4;
      for(var4 = 0; (var2 = this.nextConsumer(var2, var3)) != null; ++var4) {
         var2.consumer.setProperties(var1);
      }

      return var4;
   }

   int setColorModel(ColorModel var1) {
      ConsumerQueue var2 = null;
      Thread var3 = Thread.currentThread();

      int var4;
      for(var4 = 0; (var2 = this.nextConsumer(var2, var3)) != null; ++var4) {
         var2.consumer.setColorModel(var1);
      }

      return var4;
   }

   int setHints(int var1) {
      ConsumerQueue var2 = null;
      Thread var3 = Thread.currentThread();

      int var4;
      for(var4 = 0; (var2 = this.nextConsumer(var2, var3)) != null; ++var4) {
         var2.consumer.setHints(var1);
      }

      return var4;
   }

   int setPixels(int var1, int var2, int var3, int var4, ColorModel var5, byte[] var6, int var7, int var8) {
      ConsumerQueue var9 = null;
      Thread var10 = Thread.currentThread();
      if (var10.getPriority() > 3) {
         var10.setPriority(3);
      }

      int var11;
      for(var11 = 0; (var9 = this.nextConsumer(var9, var10)) != null; ++var11) {
         var9.consumer.setPixels(var1, var2, var3, var4, var5, var6, var7, var8);
      }

      return var11;
   }

   int setPixels(int var1, int var2, int var3, int var4, ColorModel var5, int[] var6, int var7, int var8) {
      ConsumerQueue var9 = null;
      Thread var10 = Thread.currentThread();
      if (var10.getPriority() > 3) {
         var10.setPriority(3);
      }

      int var11;
      for(var11 = 0; (var9 = this.nextConsumer(var9, var10)) != null; ++var11) {
         var9.consumer.setPixels(var1, var2, var3, var4, var5, var6, var7, var8);
      }

      return var11;
   }

   int imageComplete(int var1) {
      ConsumerQueue var2 = null;
      Thread var3 = Thread.currentThread();

      int var4;
      for(var4 = 0; (var2 = this.nextConsumer(var2, var3)) != null; ++var4) {
         var2.consumer.imageComplete(var1);
      }

      return var4;
   }
}